<!DOCTYPE HTML>
<html lang="zh-CN">


<head><meta name="generator" content="Hexo 3.9.0">
    <meta charset="utf-8">
    <meta name="keywords" content="Java集合框架知识整理, 闪烁之狐, Blinkfox">
    <meta name="description" content="Java集合框架主要由Collection和Map两个根接口及其子接口、实现类组成。
集合类关系梳理
Collection接口继承了Iterable接口，依赖了Predicate、Spliterator、Stream接口（这些均为Java8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
    <meta name="renderer" content="webkit|ie-stand|ie-comp">
    <meta name="mobile-web-app-capable" content="yes">
    <meta name="format-detection" content="telephone=no">
    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
    <title>Java集合框架知识整理 | 闪烁之狐</title>
    <link rel="icon" type="image/png" href="/favicon.png">

    <link rel="stylesheet" type="text/css" href="/libs/awesome/css/font-awesome.min.css">
    <link rel="stylesheet" type="text/css" href="/libs/materialize/materialize.min.css">
    <link rel="stylesheet" type="text/css" href="/libs/aos/aos.css">
    <link rel="stylesheet" type="text/css" href="/libs/animate/animate.min.css">
    <link rel="stylesheet" type="text/css" href="/libs/lightGallery/css/lightgallery.min.css">
    <link rel="stylesheet" type="text/css" href="/css/matery.css">
    <link rel="stylesheet" type="text/css" href="/css/my.css">
    <style type="text/css">
        
        code[class*="language-"], pre[class*="language-"] {
            white-space: pre !important;
        }
        
    </style>

    <script src="/libs/jquery/jquery-2.2.0.min.js"></script>
<link rel="stylesheet" href="/css/prism-tomorrow.css" type="text/css"></head>


<body>

<header class="navbar-fixed">
    <nav id="headNav" class="bg-color nav-transparent">
        <div id="navContainer" class="nav-wrapper container">
            <div class="brand-logo">
                <a href="/" class="waves-effect waves-light">
                    
                    <img src="/medias/logo.png" class="logo-img" alt="LOGO">
                    
                    <span class="logo-span">闪烁之狐</span>
                </a>
            </div>
            

<a href="#" data-target="mobile-nav" class="sidenav-trigger button-collapse"><i class="fa fa-navicon"></i></a>
<ul class="right">
    
    <li class="hide-on-med-and-down">
        <a href="/" class="waves-effect waves-light">
            
            <i class="fa fa-home"></i>
            
            <span>首页</span>
        </a>
    </li>
    
    <li class="hide-on-med-and-down">
        <a href="/tags" class="waves-effect waves-light">
            
            <i class="fa fa-tags"></i>
            
            <span>标签</span>
        </a>
    </li>
    
    <li class="hide-on-med-and-down">
        <a href="/categories" class="waves-effect waves-light">
            
            <i class="fa fa-bookmark"></i>
            
            <span>分类</span>
        </a>
    </li>
    
    <li class="hide-on-med-and-down">
        <a href="/archives" class="waves-effect waves-light">
            
            <i class="fa fa-archive"></i>
            
            <span>归档</span>
        </a>
    </li>
    
    <li class="hide-on-med-and-down">
        <a href="/about" class="waves-effect waves-light">
            
            <i class="fa fa-user-circle-o"></i>
            
            <span>关于</span>
        </a>
    </li>
    
    <li class="hide-on-med-and-down">
        <a href="/friends" class="waves-effect waves-light">
            
            <i class="fa fa-address-book"></i>
            
            <span>友情链接</span>
        </a>
    </li>
    
    <li>
        <a href="#searchModal" class="modal-trigger waves-effect waves-light">
            <i id="searchIcon" class="fa fa-search" title="搜索"></i>
        </a>
    </li>
</ul>

<div id="mobile-nav" class="side-nav sidenav">

    <div class="mobile-head bg-color">
        
        <img src="/medias/logo.png" class="logo-img circle responsive-img">
        
        <div class="logo-name">闪烁之狐</div>
        <div class="logo-desc">
            
            从来没有真正的绝境，只有心灵的迷途
            
        </div>
    </div>

    

    <ul class="menu-list mobile-menu-list">
        
        <li>
            <a href="/" class="waves-effect waves-light">
                
                <i class="fa fa-fw fa-home"></i>
                
                首页
            </a>
        </li>
        
        <li>
            <a href="/tags" class="waves-effect waves-light">
                
                <i class="fa fa-fw fa-tags"></i>
                
                标签
            </a>
        </li>
        
        <li>
            <a href="/categories" class="waves-effect waves-light">
                
                <i class="fa fa-fw fa-bookmark"></i>
                
                分类
            </a>
        </li>
        
        <li>
            <a href="/archives" class="waves-effect waves-light">
                
                <i class="fa fa-fw fa-archive"></i>
                
                归档
            </a>
        </li>
        
        <li>
            <a href="/about" class="waves-effect waves-light">
                
                <i class="fa fa-fw fa-user-circle-o"></i>
                
                关于
            </a>
        </li>
        
        <li>
            <a href="/friends" class="waves-effect waves-light">
                
                <i class="fa fa-fw fa-address-book"></i>
                
                友情链接
            </a>
        </li>
        
        
        <li><div class="divider"></div></li>
        <li>
            <a href="https://github.com/blinkfox/hexo-theme-matery" class="waves-effect waves-light" target="_blank">
                <i class="fa fa-github-square fa-fw"></i>Fork Me
            </a>
        </li>
        
    </ul>
</div>

        </div>

        
            <style>
    .nav-transparent .github-corner {
        display: none !important;
    }

    .github-corner {
        position: absolute;
        z-index: 10;
        top: 0;
        right: 0;
        border: 0;
        transform: scale(1.1);
    }

    .github-corner svg {
        color: #0f9d58;
        fill: #fff;
        height: 64px;
        width: 64px;
    }

    .github-corner:hover .octo-arm {
        animation: a 0.56s ease-in-out;
    }

    .github-corner .octo-arm {
        animation: none;
    }

    @keyframes a {
        0%,
        to {
            transform: rotate(0);
        }
        20%,
        60% {
            transform: rotate(-25deg);
        }
        40%,
        80% {
            transform: rotate(10deg);
        }
    }
</style>

<a href="https://github.com/blinkfox/hexo-theme-matery" class="github-corner tooltipped hide-on-med-and-down" target="_blank"
   data-tooltip="Fork Me" data-position="left" data-delay="50">
    <svg viewBox="0 0 250 250" aria-hidden="true">
        <path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path>
        <path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2"
              fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path>
        <path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z"
              fill="currentColor" class="octo-body"></path>
    </svg>
</a>
        
    </nav>

</header>





<div class="bg-cover pd-header post-cover" style="background-image: url('http://static.blinkfox.com/20181024-collections.jpg')">
    <div class="container">
        <div class="row">
            <div class="col s12 m12 l12">
                <div class="brand">
                    <div class="description center-align post-title">
                        Java集合框架知识整理
                    </div>
                </div>
            </div>
        </div>
    </div>
</div>



<main class="post-container content">

    
    <link rel="stylesheet" href="/libs/tocbot/tocbot.css">
<style>
    #articleContent h1::before,
    #articleContent h2::before,
    #articleContent h3::before,
    #articleContent h4::before,
    #articleContent h5::before,
    #articleContent h6::before {
        display: block;
        content: " ";
        height: 100px;
        margin-top: -100px;
        visibility: hidden;
    }

    #articleContent :focus {
        outline: none;
    }

    .toc-fixed {
        position: fixed;
        top: 64px;
    }

    .toc-widget {
        padding-left: 20px;
    }

    .toc-widget .toc-title {
        margin: 35px 0 15px 0;
        padding-left: 17px;
        font-size: 1.5rem;
        font-weight: bold;
        line-height: 1.5rem;
    }

    .toc-widget ol {
        padding: 0;
        list-style: none;
    }

    #toc-content ol {
        padding-left: 10px;
    }

    #toc-content ol li {
        padding-left: 10px;
    }

    #toc-content .toc-link:hover {
        color: #42b983;
        font-weight: 700;
        text-decoration: underline;
    }

    #toc-content .toc-link::before {
        background-color: transparent;
        max-height: 25px;
    }

    #toc-content .is-active-link {
        color: #42b983;
    }

    #toc-content .is-active-link::before {
        background-color: #42b983;
    }
</style>
<div class="row">
    <div class="col s12 m12 l9">
        <!-- 文章内容详情 -->
<div id="artDetail">
    <div class="card">
        <div class="card-content article-info">
            <div class="row tag-cate">
                <div class="col s7">
                    
                    <div class="article-tag">
                        
                            <a href="/tags/Java/" target="_blank">
                                <span class="chip bg-color">Java</span>
                            </a>
                        
                            <a href="/tags/UML/" target="_blank">
                                <span class="chip bg-color">UML</span>
                            </a>
                        
                    </div>
                    
                </div>
                <div class="col s5 right-align">
                    
                    <div class="post-cate">
                        <i class="fa fa-bookmark fa-fw icon-category"></i>
                        
                            <a href="/categories/后端/" class="post-category" target="_blank">
                                后端
                            </a>
                        
                    </div>
                    
                </div>
            </div>

            <div class="post-info">
                <div class="post-date info-break-policy">
                    <i class="fa fa-calendar-minus-o fa-fw"></i>发布日期:&nbsp;&nbsp;
                    2018-10-24
                </div>

                
                    
                    <div class="info-break-policy">
                        <i class="fa fa-file-word-o fa-fw"></i>文章字数:&nbsp;&nbsp;
                        5.9k
                    </div>
                    

                    
                    <div class="info-break-policy">
                        <i class="fa fa-clock-o fa-fw"></i>阅读时长:&nbsp;&nbsp;
                        22 分
                    </div>
                    
                
				
				
                    <div id="busuanzi_container_page_pv" class="info-break-policy">
                        <i class="fa fa-eye fa-fw"></i>阅读次数:&nbsp;&nbsp;
                        <span id="busuanzi_value_page_pv"></span>
                    </div>
				
            </div>
        </div>
        <hr class="clearfix">
        <div class="card-content article-card-content">
            <div id="articleContent">
                <p>Java集合框架主要由<code>Collection</code>和<code>Map</code>两个根接口及其子接口、实现类组成。</p>
<h2 id="集合类关系梳理"><a href="#集合类关系梳理" class="headerlink" title="集合类关系梳理"></a>集合类关系梳理</h2><ul>
<li><code>Collection</code>接口继承了<code>Iterable</code>接口，依赖了<code>Predicate</code>、<code>Spliterator</code>、<code>Stream</code>接口（这些均为<code>Java8</code>新增），<code>Iterable</code>接口依赖了<code>Iterator</code>接口。<ul>
<li><code>List</code>接口继承自<code>Collection</code>接口,依赖了<code>UnaryOperator</code>接口（<code>Java8</code>新增）、<code>ListIterator</code>、<code>Comparator</code>接口</li>
<li><code>Queue</code>接口继承了<code>Collection</code>接口<ul>
<li><code>Deque</code>接口继承了<code>Queue</code>接口</li>
<li><code>BlockingQueue</code>接口继承了<code>Queue</code>接口<ul>
<li><code>BlockingDeque</code>接口继承了<code>BlockingQueue</code>、<code>Deque</code>接口</li>
<li><code>TransferQueue</code>接口继承了<code>BlockingQueue</code>接口</li>
</ul>
</li>
</ul>
</li>
<li><code>AbstractCollection</code>抽象类实现了<code>Collection</code>接口，<ul>
<li><code>AbstractList</code>抽象类继承了<code>AbstractCollection</code>抽象类，实现了<code>List</code>接口，依赖了<code>List</code>、<code>RandomAccess</code>、<code>Cloneable</code>、<code>Serializable</code>接口<ul>
<li><code>ArrayList</code>类继承了<code>AbstractList</code>抽象类，实现了<code>List</code>、<code>RandomAccess</code>、<code>Cloneable</code>、<code>Serializable</code>接口</li>
<li><code>AbstractSequentialList</code>抽象类继承了<code>AbstractList</code>抽象类<ul>
<li><code>LinkedList</code>类继承了<code>AbstractSequentialList</code>抽象类，实现了<code>List</code>、<code>Deque</code>、<code>Cloneable</code>、<code>Serializable</code>接口</li>
</ul>
</li>
<li><code>CopyOnWriteArrayList</code>实现了<code>List</code>、<code>RandomAccess</code>、<code>Cloneable</code>、<code>Serializable</code>接口</li>
<li><code>Vector</code>类继承了<code>AbstractList</code>抽象类，实现了<code>List</code>、<code>RandomAccess</code>、<code>Cloneable</code>、<code>Serializable</code>接口<ul>
<li><code>Stack</code>类继承了<code>Vector</code>类</li>
</ul>
</li>
</ul>
</li>
<li><code>AbstractQueue</code>抽象类继承了<code>AbstractCollection</code>接口，实现了<code>Queue</code>接口<ul>
<li><code>SynchronousQueue</code>类继承了<code>AbstractQueue</code>接口，实现了<code>BlockingQueue</code>、<code>Serializable</code>接口，依赖了<code>Collection</code>、<code>Spliterator</code>接口</li>
<li><code>ArrayBlockingQueue</code>类继承了<code>AbstractQueue</code>接口，实现了<code>BlockingQueue</code>、<code>Serializable</code>接口</li>
<li><code>LinkedBlockingQueue</code>类继承了<code>AbstractQueue</code>接口，实现了<code>BlockingQueue</code>、<code>Serializable</code>接口</li>
<li><code>PriorityBlockingQueue</code>类继承了<code>AbstractQueue</code>接口，实现了<code>BlockingQueue</code>、<code>Serializable</code>接口，聚合了<code>Comparator</code>接口，依赖了<code>Collection</code>、<code>Comparator</code>、<code>Comparable</code>接口</li>
<li><code>DelayQueue</code>类继承了<code>AbstractQueue</code>接口，实现了<code>BlockingQueue</code>接口</li>
<li><code>LinkedBlockingDeque</code>类继承了<code>AbstractQueue</code>接口，实现了<code>BlockingDeque</code>、<code>Serializable</code>接口</li>
<li><code>PriorityQueue</code>类继承了<code>AbstractQueue</code>接口</li>
<li><code>LinkedTransferQueue</code>类继承了<code>AbstractQueue</code>接口，实现了<code>TransferQueue</code>、<code>Serializable</code>接口（Java7新增）</li>
</ul>
</li>
<li><code>ConcurrentLinkedDeque</code>类继承了<code>AbstractCollection</code>抽象类，实现了<code>Deque</code>、<code>Cloneable</code>、<code>Serializable</code>接口</li>
<li><code>ArrayDeque</code>类继承了<code>AbstractCollection</code>抽象类，实现了<code>Deque</code>、<code>Serializable</code>接口</li>
</ul>
</li>
<li><code>Set</code>接口继承自<code>Collection</code>接口<ul>
<li><code>AbstractSet</code>抽象类继承了<code>AbstractCollection</code>抽象类，实现了<code>Set</code>接口<ul>
<li><code>HashSet</code>类继承了<code>AbstractSet</code>抽象类，实现了<code>Set</code>、<code>Cloneable</code>、<code>Serializable</code>接口，聚合了<code>HashMap</code><ul>
<li><code>LinkedHashSet</code>类继承了<code>HashSet</code>类，实现了<code>Set</code>、<code>Cloneable</code>、<code>Serializable</code>接口</li>
</ul>
</li>
<li><code>TreeSet</code>类继承了<code>AbstractSet</code>抽象类，实现了<code>NavigableSet</code>、<code>Cloneable</code>、<code>Serializable</code>接口，聚合了<code>NavigableMap</code>，依赖了<code>Comparator</code>、<code>SortedSet</code>接口</li>
<li><code>EnumSet</code>抽象类继承了<code>AbstractSet</code>抽象类，实现了<code>Cloneable</code>、<code>Serializable</code>接口，依赖了<code>Comparator</code>、<code>SortedSet</code>接口<ul>
<li><code>RegularEnumSet</code>类继承了<code>EnumSet</code>抽象类</li>
<li><code>JumboEnumSet</code>类继承了<code>EnumSet</code>抽象类</li>
</ul>
</li>
<li><code>ConcurrentSkipListSet</code>类继承了<code>AbstractSet</code>抽象类，实现了<code>NavigableSet</code>、<code>Cloneable</code>、<code>Serializable</code>接口</li>
<li><code>CopyOnWriteArraySet</code>类继承了<code>AbstractSet</code>抽象类，实现了<code>Serializable</code>接口，聚合了<code>CopyOnWriteArrayList</code>类，依赖了<code>Predicate</code>、<code>Consumer</code>接口</li>
</ul>
</li>
<li><code>SortedSet</code>接口继承自<code>Set</code>接口，依赖了<code>Comparator</code>接口<ul>
<li><code>NavigableSet</code>接口继承自<code>SortedSet</code>接口(Java6新增)</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
<li><code>Map</code>接口依赖了<code>Set</code>、<code>Collection</code>、<code>BiConsumer</code>、<code>Function</code>、<code>BiFunction</code>接口，<code>Map.Entry</code>是Map中的内部接口<ul>
<li><code>AbstractMap</code>抽象类实现了<code>Map</code>接口，聚合了<code>Collection</code>、<code>Set</code>接口<ul>
<li><code>HashMap</code>类继承了<code>AbstractMap</code>抽象类，实现了<code>Map</code>、<code>Cloneable</code>、<code>Serializable</code>接口，依赖了<code>Collection</code>、<code>Set</code>接口<ul>
<li><code>LinkedHashMap</code>继承了<code>HashMap</code>类，实现了<code>Map</code>接口，依赖了<code>Collection</code>、<code>Set</code>、<code>Consumer</code>、<code>BiConsumer</code>接口</li>
</ul>
</li>
<li><code>TreeMap</code>类继承了<code>AbstractMap</code>抽象类，实现了<code>NavigableMap</code>、<code>Cloneable</code>、<code>Serializable</code>接口，依赖了<code>Comparator</code>、<code>SortedMap</code>、<code>Collection</code>、<code>Set</code>、<code>BiConsumer</code>、<code>BiFunction</code>接口</li>
<li><code>EnumMap</code>类继承了<code>AbstractMap</code>抽象类，实现了<code>Cloneable</code>、<code>Serializable</code>接口，依赖了<code>AbstractSet</code>类，<code>Collection</code>、<code>Set</code>接口</li>
<li><code>WeakHashMap</code>类继承了<code>AbstractMap</code>抽象类，实现了<code>Map</code>接口，依赖了<code>Collection</code>、<code>Set</code>、<code>Consumer</code>、<code>BiConsumer</code>、<code>BiFunction</code>接口</li>
<li><code>IdentityHashMap</code>类继承了<code>AbstractMap</code>抽象类，实现了<code>Map</code>、<code>Serializable</code>、<code>Cloneable</code>接口，依赖了<code>Collection</code>、<code>Set</code>、<code>Consumer</code>、<code>BiConsumer</code>、<code>BiFunction</code>接口</li>
<li><code>ConcurrentHashMap</code>类继承了<code>AbstractMap</code>抽象类，实现了<code>ConcurrentMap</code>、<code>Serializable</code>接口，依赖了<code>Comparable</code>、<code>ParameterizedType</code>、<code>Collection</code>、<code>Set</code>、<code>Spliterator</code>、<code>Consumer</code>、<code>BiConsumer</code>、<code>Function</code>、<code>BiFunction</code>、<code>ToDoubleFunction</code>、<code>DoubleBinaryOperator</code>等接口</li>
<li><code>ConcurrentSkipListMap</code>类继承了<code>AbstractMap</code>抽象类，实现了<code>ConcurrentNavigableMap</code>、<code>Cloneable</code>、<code>Serializable</code>接口，聚合了<code>Comparator</code>接口，依赖了<code>Collection</code>、<code>Set</code>、<code>Consumer</code>、<code>BiConsumer</code>、<code>BiFunction</code>、<code>NavigableSet</code>接口</li>
</ul>
</li>
<li><code>SortedMap</code>接口继承自<code>Map</code>接口，依赖了<code>Set</code>、<code>Collection</code>、<code>Comparator</code>接口<ul>
<li><code>NavigableMap</code>接口继承了<code>SortedMap</code>接口，依赖了<code>NavigableSet</code>接口</li>
<li><code>ConcurrentNavigableMap</code>接口继承了<code>ConcurrentMap</code>、<code>NavigableMap</code>接口，聚合了<code>NavigableSet</code>接口</li>
</ul>
</li>
<li><code>ConcurrentMap</code>接口继承了<code>Map</code>接口，依赖了<code>BiConsumer</code>、<code>BiFunction</code>接口</li>
<li><code>Hashtable</code>类继承了<code>Dictionary</code>抽象类，实现了<code>Map</code>、<code>Cloneable</code>、<code>Serializable</code>接口，聚合了<code>Collection</code>、<code>Set</code>接口，依赖了<code>Enumeration</code>、<code>BiConsumer</code>、<code>BiFunction</code>接口<ul>
<li><code>Properties</code>类继承了<code>Hashtable</code>类</li>
</ul>
</li>
</ul>
</li>
<li><code>Collections</code>是<code>Collection</code>的辅助工具类，依赖了上述大多数接口和类</li>
<li><code>Arrays</code>是数组的辅助工具类，依赖了上述一些接口和类</li>
</ul>
<h2 id="集合UML关系图"><a href="#集合UML关系图" class="headerlink" title="集合UML关系图"></a>集合UML关系图</h2><p>Java Collection UML类关系图如下：</p>
<p><img src="http://static.blinkfox.com/Java_Collection_UML.png" alt="Java Collection UML类关系图"></p>
<p>Java Map UML类关系图如下：</p>
<p><img src="http://static.blinkfox.com/Java_Map_UML.png" alt="Java Map UML类关系图"></p>
<h2 id="各集合接口、类的介绍"><a href="#各集合接口、类的介绍" class="headerlink" title="各集合接口、类的介绍"></a>各集合接口、类的介绍</h2><ul>
<li><code>Collection</code>：<code>Collection</code>是最基本集合接口，它定义了一组允许重复的对象。<code>Collection</code>接口派生了三个子接口<code>List</code>、<code>Set</code>和<code>Queue</code>。<code>Collection</code>所有实现类的遍历都可以使用<code>Iterator</code>接口或者是<code>foreach</code>来循环。<ul>
<li><code>List</code>：<code>List</code>代表有序、可重复的集合。<ul>
<li><code>ArrayList</code>：底层使用数组的形式来实现，排列有序可重复，查询速度快、增删数据慢，线程不安全，效率高。<code>ArrayList</code>创建时的大小为<code>0</code>；当加入第一个元素时，进行第一次扩容时，默认容量大小为<code>10</code>，每次扩容都以当前数组大小的1.5倍去扩容。</li>
<li><code>Vector</code>：底层使用数组的形式来实现，排列有序可重复，查询速度快、增删数据慢，线程安全，效率低。<code>Vector</code>创建时的默认大小为<code>10</code>；<code>Vector</code>每次扩容都以当前数组大小的<code>2</code>倍去扩容。当指定了<code>capacityIncrement</code>之后，每次扩容仅在原先基础上增加<code>capacityIncrement</code>个单位空间。<code>ArrayList</code>和<code>Vector</code>的<code>add</code>、<code>get</code>、<code>size</code>方法的复杂度都为<code>O(1)</code>，<code>remove</code>方法的复杂度为<code>O(n)</code>。<ul>
<li><code>Stack</code>：<code>Vector</code>的一个子类，是标准的<strong>先进后出</strong>(FILO, First In Last Out)的栈。底层通过数组实现的，线程安全。</li>
</ul>
</li>
<li><code>LinkedList</code>：底层使用双向循环链表的数据结构来实现，排列有序可重复，查询速度慢、增删数据快，线程不安全。</li>
<li><code>CopyOnWriteArrayList</code>：底层使用<code>Copy-On-Write</code>的优化策略实现，适用于<strong>读多写少</strong>的场景，同<code>ArrayList</code>功能相似，线程安全。<code>CopyOnWriteArrayList</code>在某些情况下比<code>Collections.synchronizedList(List list)</code>有更好的性能。缺点是：内存占用大和数据一致性问题，只能保证最终一致性。</li>
</ul>
</li>
<li><code>Set</code>：<code>Set</code>代表无序、不可重复的集合。<ul>
<li><code>HastSet</code>：底层使用<code>Hash</code>表来实现，内部使用了<code>HashMap</code>，排列无序不可重复，存取速度快，线程不安全。<ul>
<li><code>LinkedHashSet</code>：底层采用<code>Hash</code>表存储，并用双向链表记录插入顺序，排列有序不可重复，存取速度较<code>HashSet</code>略慢，比<code>TreeSet</code>快，线程不安全。</li>
</ul>
</li>
<li><code>TreeSet</code>：底层使用红黑树来实现，内部使用了<code>NavigableMap</code>，按自然顺序或者自定义顺序存放、不可重复，线程不安全。</li>
<li><code>CopyOnWriteArraySet</code>：底层使用<code>Copy-On-Write</code>的优化策略实现，适用于<strong>读多写少</strong>的场景，内部使用了<code>CopyOnWriteArrayList</code>，同<code>HastSet</code>功能相似，线程安全。</li>
<li><code>ConcurrentSkipListSet</code>：底层使用<strong>跳跃列表</strong>来实现，适用于<strong>高并发</strong>的场景，内部使用了<code>ConcurrentNavigableMap</code>，同<code>TreeSet</code>功能相似，线程安全。</li>
<li><code>EnumSet</code>：是抽象类，只能用来存储Enum常量或其子类，不能存储其它类型，<code>EnumSet</code>有两种实现方式，<code>RegularEnumSet</code>和<code>JumboEnumSet</code>，但是这两种实现方式是包<strong>私有</strong>的，不能在包外访问，因此必须使用工厂方法来创建并返回<code>EnumSet</code>实例，不能通过构造函数来创建。<code>EnumSet</code>中提供了多种创建<code>EnumSet</code>实例的静态工厂方法，例如<code>of</code>方法（进行了函数重载），<code>copyOf</code>方法，<code>noneOf</code>方法等。存储效率快，线程不安全。存储枚举常量时使用<code>EnumSet</code>而不要用<code>HashSet</code>。</li>
</ul>
</li>
<li><code>Queue</code>：<code>Queue</code>是Java 5之后增加的集合体系，表示<strong>队列</strong>集合的相关实现，大多遵循<strong>先进先出</strong>(FIFO, First-In-First-Out)的模式。<ul>
<li><code>PriorityQueue</code>：即优先队列，底层基于<strong>优先堆的一个无界队列</strong>来实现，无界但可选容量界限。这个优先队列中的元素可以默认自然排序或者通过提供的<code>Comparator</code>（比较器）在队列实例化的时排序，而不是先进先出。不允许空值、不支持<code>non-comparable</code>（不可比较）的对象，每次从队列中取出的是具有最高优先权的元素，线程不安全。</li>
<li><code>ArrayBlockingQueue</code>：底层基于<strong>定长数组</strong>的阻塞队列实现，即是线程安全的有界阻塞队列。<code>ArrayBlockingQueue</code>内部通过<strong>互斥锁</strong>保护竞争资源，实现了多线程对竞争资源的互斥访问。队列中的锁是没有分离的，所以在添加的同时就不能读取，读取的同时就不能添加，所以锁方面性能不如<code>LinkedBlockingQueue</code>。</li>
<li><code>LinkedBlockingQueue</code>：即链接队列，底层基于<strong>单向链表</strong>的阻塞队列实现，无界但可选容量界限，线程安全。队列中的锁是分离的，即添加用的是<code>putLock</code>，获取是<code>takeLock</code>，所以在添加获取方面理论上性能会高于<code>ArrayBlockingQueue</code>。所以<code>LinkedBlockingQueue</code>更适合实现生产者-消费者队列。</li>
<li><code>PriorityBlockingQueue</code>：即优先阻塞队列，底层基于<strong>优先堆的一个无界队列</strong>来实现，无界但可选容量界限的阻塞队列，线程安全，功能同<code>PriorityQueue</code>、<code>LinkedBlockQueue</code>相似。其所含对象的排序不是先进先出，而是依据对象的自然排序顺序或者是构造函数的<code>Comparator</code>决定的顺序。</li>
<li><code>SynchronousQueue</code>：即同步队列，是一种线程安全无缓冲的无界阻塞队列。其操作必须是放和取交替完成的，即每个<code>put</code>必须等待一个<code>take</code>，反之亦然。</li>
<li><code>DelayQueue</code>：即延迟队列，是一种有序无界阻塞队列，只有在延迟期满时才能从中提取元素，线程安全。</li>
<li><code>ArrayDeque</code>：底层采用了循环数组的方式来完成双端队列的实现，无限扩展且可选容量。Java已不推荐使用<code>Stack</code>，而是推荐使用更高效的<code>ArrayDeque</code>来实现栈的功能，非线程安全。</li>
<li><code>LinkedBlockingDeque</code>：底层采用了<strong>双向链表</strong>实现的<strong>双端阻塞并发</strong>队列，无限扩展且可选容量。该阻塞队列同时支持<code>FIFO</code>和<code>FILO</code>两种操作方式，即可以从队列的头和尾同时操作(插入/删除)，且线程安全。</li>
<li><code>ConcurrentLinkedDeque</code>：底层采用了<strong>双向链表</strong>实现的<strong>双端非阻塞并发</strong>队列，无限扩展且可选容量。该队列同时支持<code>FIFO</code>和<code>FILO</code>两种操作方式，即可以从队列的头和尾同时操作(插入/删除)，且线程安全。</li>
<li><code>LinkedTransferQueue</code>：底层采用了<strong>单向链表</strong>实现的<strong>无界传输阻塞</strong>队列，先进先出，无限扩展且可选容量线程安全。</li>
</ul>
</li>
</ul>
</li>
<li><code>Map</code>：<code>Map</code>代表具有映射关系的集合。<ul>
<li><code>HashMap</code>：底层是用<strong>链表数组</strong>，<code>Java8</code>后又加了<strong>红黑树</strong>来实现，键无序不可重复可为null、值可重复可为null，存取速度快，线程不安全。<ul>
<li><code>LinkedHashMap</code>：底层是用<strong>链表数组</strong>存储，并用双向链表记录插入顺序，键有序不可重复可为null、值可重复可为null，存取速度快较<code>HashMap</code>略慢，比<code>TreeMap</code>快，线程不安全。</li>
</ul>
</li>
<li><code>HashTable</code>：底层是用<strong>链表数组</strong>，键无序不可重复可为null、值可重复可为null，存取速度较<code>HashMap</code>慢，线程安全。<ul>
<li><code>Properties</code>：是<code>HashTable</code>的子类，是&lt;String,String&gt;的映射，比<code>HashTable</code>多了<code>load</code>、<code>store</code>两个方法，线程安全。</li>
</ul>
</li>
<li><code>TreeMap</code>：底层使用红黑树来实现，内部使用了<code>Comparator</code>，按自然顺序或自定义顺序存放键，键不可重复不可为null、值可重复可为null，存取速度较<code>HashMap</code>慢，线程不安全。</li>
<li><code>EnumMap</code>：底层使用数组来实现，是专门为枚举类型量身定做的Map，性能更好。只能接收同一枚举类型的实例作为键值，并且由于枚举类型实例的数量相对固定并且有限，所以<code>EnumMap</code>使用数组来存放与枚举类型对应的值，线程不安全。</li>
<li><code>WeakHashMap</code>：同<code>HashMap</code>基本相似。区别在于，<code>HashMap</code>的<code>key</code>保留对象的强引用，这意味着只要该<code>HashMap</code>对象不被销毁，该<code>HashMap</code>对象所有key所引用的对象不会被垃圾回收，<code>HashMap</code>也不会自动删除这些<code>key</code>所对应的<code>key-value</code>对象；但<code>WeakHashMap</code>的<code>key</code>只保留对实际对象的弱引用，这意味着当垃圾回收了该<code>key</code>所对应的实际对象后，<code>WeakHashMap</code>会自动删除该<code>key</code>对应的<code>key-value</code>对象。</li>
<li><code>IdentityHashMap</code>：同<code>HashMap</code>基本相似。区别在于，在处理两个<code>key</code>相等时，对于普通<code>HashMap</code>而言，只要<code>key1</code>和<code>key2</code>通过<code>equals</code>比较返回<code>true</code>时就认为key相同；在<code>IdentityHashMap</code>中，当且仅当两个<code>key</code>严格相等时(<code>key1 = key2</code>)时才认为两个<code>key</code>相同。</li>
<li><code>ConcurrentHashMap</code>：底层使用<strong>锁分段</strong>技术来实现线程安全，首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。<code>ConcurrentHashMap</code>是由<code>Segment</code>数组结构和<code>HashEntry</code>数组结构组成。<code>Segment</code>是一种可重入锁<code>ReentrantLock</code>，在<code>ConcurrentHashMap</code>里扮演锁的角色，<code>HashEntry</code>则用于存储键值对数据。一个<code>ConcurrentHashMap</code>里包含一个<code>Segment</code>数组，<code>Segment</code>的结构和<code>HashMap</code>类似，是一种数组和链表结构， 一个<code>Segment</code>里包含一个<code>HashEntry</code>数组，每个<code>HashEntry</code>是一个链表结构的元素， 每个<code>Segment</code>守护者一个<code>HashEntry</code>数组里的元素,当对<code>HashEntry</code>数组的数据进行修改时，必须首先获得它对应的<code>Segment</code>锁。</li>
<li><code>ConcurrentSkipListMap</code>：底层使用<strong>跳跃列表</strong>来实现，适用于<strong>高并发</strong>的场景，内部使用了<code>ConcurrentNavigableMap</code>，同<code>TreeMap</code>功能相似，是一个并发的、可排序的Map，线程安全。因此它可以在多线程环境中弥补<code>ConcurrentHashMap</code>不支持排序的问题。</li>
</ul>
</li>
</ul>
<p>Java集合框架功能介绍思维导图如下：</p>
<p><img src="http://static.blinkfox.com/Java_collections_mind.png" alt="Java集合框架功能介绍思维导图"></p>
<h3 id="一些概念解释"><a href="#一些概念解释" class="headerlink" title="一些概念解释"></a>一些概念解释</h3><ul>
<li><strong>跳表</strong>：是一种采用了用空间换时间思想的数据结构。它会随机地将一些节点提升到更高的层次，以创建一种逐层的数据结构，以提高操作的速度。</li>
<li><strong>阻塞队列和非阻塞的区别</strong>：如果队列里面已经放满了，如果是阻塞队列那么线程会一直阻塞，而非阻塞对垒则会抛出异常。</li>
</ul>
<h3 id="一些数据结构的优缺点"><a href="#一些数据结构的优缺点" class="headerlink" title="一些数据结构的优缺点"></a>一些数据结构的优缺点</h3><ul>
<li><strong>Hash表</strong>：插入、查找最快，为O(1)；如使用链表实现则可实现无锁；数据有序化需要显式的排序操作。</li>
<li><strong>红黑树</strong>：插入、查找为O(logn)，但常数项较小；无锁实现的复杂性很高，一般需要加锁；数据天然有序。</li>
<li><strong>SkipList</strong>：插入、查找为O(logn)，但常数项比红黑树要大；底层结构为链表，可无锁实现；数据天然有序。</li>
</ul>
<h2 id="一些接口的主要方法梳理"><a href="#一些接口的主要方法梳理" class="headerlink" title="一些接口的主要方法梳理"></a>一些接口的主要方法梳理</h2><h3 id="Collection接口中的抽象方法"><a href="#Collection接口中的抽象方法" class="headerlink" title="Collection接口中的抽象方法"></a>Collection接口中的抽象方法</h3><ul>
<li><code>int size()</code>，返回集合的大小</li>
<li><code>boolean isEmpty()</code>，返回集合是否为空的布尔值</li>
<li><code>boolean contains(Object o)</code>，返回集合是否包含元素<code>o</code>的布尔值</li>
<li><code>Iterator&lt;E&gt; iterator()</code>，返回该集合中元素的迭代器，继承自<code>Iterable</code>接口</li>
<li><code>Object[] toArray()</code>，返回一个包含此集合中所有元素的数组</li>
<li><code>&lt;T&gt; T[] toArray(T[] a)</code>，<code>toArray()</code>方法的泛型版本，返回一个包含此集合中所有元素的数组，返回类型由传入数组参数的类型决定</li>
<li><code>boolean add(E e)</code>，返回向集合中插入元素<code>e</code>是否成功的布尔值</li>
<li><code>boolean remove(Object o)</code>，返回从集合中删除元素<code>o</code>是否成功的布尔值</li>
<li><code>boolean containsAll(Collection&lt;?&gt; c)</code>，返回本集合中是否完全包含集合<code>c</code>的布尔值，即判断集合<code>c</code>是否是本集合子集</li>
<li><code>boolean addAll(Collection&lt;? extends E&gt; c)</code>，将集合<code>c</code>中的所有元素添加到本集合中并返回</li>
<li><code>boolean removeAll(Collection&lt;?&gt; c)</code>，移除本集合中所有包含集合<code>c</code>的所有元素</li>
<li><code>default boolean removeIf(Predicate&lt;? super E&gt; filter)</code>，Java8新增的接口默认方法。将会批量删除符合filter条件的所有元素，该方法需要一个Predicate对象作为作为参数，Predicate也是函数式接口，因此可使用Lambda表达式作为参数。</li>
<li><code>boolean retainAll(Collection&lt;?&gt; c)</code>，返回本集合和集合<code>c</code>中相同的元素并存到本集合中,集合<code>c</code>保持不变，返回值表示的是本集合是否发生过改变。即该方法是用来求两个集合的交集，交集的结果存到本集合中，如果本集合没发生变化则返回<code>true</code></li>
<li><code>void clear()</code>，清空本集合中的所有元素</li>
<li><code>boolean equals(Object o)</code>，返回本集合是否和对象<code>o</code>相等的布尔值</li>
<li><code>int hashCode()</code>，返回此集合的<code>Hash</code>码值</li>
<li><code>default Spliterator&lt;E&gt; spliterator()</code>，在集合中创建<code>Spliterator</code>对象<ul>
<li><code>Spliterator</code>是Java 8引入的新接口，顾名思义，<code>Spliterator</code>可以理解<code>Iterator</code>的<code>Split</code>版本（但用途要丰富很多）。使用<code>Iterator</code>的时候，我们可以顺序地遍历容器中的元素，使用<code>Spliterator</code>的时候，我们可以将元素分割成多份，分别交于不于的线程去遍历，以提高效率。使用<code>Spliterator</code>每次可以处理某个元素集合中的一个元素 — 不是从<code>Spliterator</code>中获取元素，而是使用<code>tryAdvance()</code>或<code>forEachRemaining()</code>方法对元素应用操作。但<code>Spliterator</code>还可以用于估计其中保存的元素数量，而且还可以像细胞分裂一样变为一分为二。这些新增加的能力让流并行处理代码可以很方便地将工作分布到多个可用线程上完成。</li>
</ul>
</li>
<li><code>default Stream&lt;E&gt; stream()</code>，返回一个顺序的<code>Stream</code>对象。Java8引入了Stream以实现对集合更方便地进行函数式编程。</li>
<li><code>default Stream&lt;E&gt; parallelStream()</code>，返回一个可能并行的<code>Stream</code>对象。Java8新增的方法。流可以是顺序的也可以是并行的。顺序流的操作是在单线程上执行的，而并行流的操作是在多线程上并发执行的。</li>
</ul>
<h3 id="List接口中的额外抽象方法"><a href="#List接口中的额外抽象方法" class="headerlink" title="List接口中的额外抽象方法"></a>List接口中的额外抽象方法</h3><ul>
<li><code>boolean addAll(int index, Collection&lt;? extends E&gt; c)</code>，将指定集合<code>c</code>中的所有元素插入到指定索引位置处</li>
<li><code>default void replaceAll(UnaryOperator&lt;E&gt; operator)</code>，Java8新增的使用<code>Lambda</code>的方式，通过应用<code>UnaryOperator</code>获得的结果来替换列表中的每个元素</li>
<li><code>default void sort(Comparator&lt;? super E&gt; c)</code>，在比较器的基础上将本列表排序</li>
<li><code>E get(int index)</code>，获取本集合中指定索引位置处的元素</li>
<li><code>E set(int index, E element)</code>，设置或替换本集合中指定索引位置处的元素</li>
<li><code>void add(int index, E element)</code>，在本集合中的指定索引位置处插入指定的元素</li>
<li><code>E remove(int index)</code>，移除本集合中指定索引位置处的元素</li>
<li><code>int indexOf(Object o)</code>，返回指定元素第一次出现的索引位置</li>
<li><code>int lastIndexOf(Object o)</code>，返回指定元素最后出现的索引位置</li>
<li><code>ListIterator&lt;E&gt; listIterator()</code>，返回本集合中的<code>ListIterator</code>迭代器</li>
<li><code>ListIterator&lt;E&gt; listIterator(int index)</code>，返回本集合中从指定索引位置开始的<code>ListIterator</code>迭代器</li>
<li><code>List&lt;E&gt; subList(int fromIndex, int toIndex)</code>，返回指定开始和结束索引位置的子集合</li>
</ul>
<h3 id="Set接口中的额外抽象方法"><a href="#Set接口中的额外抽象方法" class="headerlink" title="Set接口中的额外抽象方法"></a>Set接口中的额外抽象方法</h3><p>无</p>
<h3 id="Map接口中的抽象方法"><a href="#Map接口中的抽象方法" class="headerlink" title="Map接口中的抽象方法"></a>Map接口中的抽象方法</h3><ul>
<li><code>boolean containsKey</code>，判断本Map集合中是否包含指定的key键</li>
<li><code>boolean containsValue</code>，判断本Map集合中是否包含指定的value值</li>
<li><code>V get(Object key)</code>，根据key获取本Map集合中的value值</li>
<li><code>V get(Object key)</code>，向本Map集合中存放key键和value值,返回value值</li>
<li><code>V remove(Object key)</code>，根据key删除本Map集合中的key和value值，并返回删除的value值</li>
<li><code>void putAll(Map&lt;? extends K, ? extends V&gt; m)</code>，将指定的Map集合添加到本的Map集合当中</li>
<li><code>Set&lt;K&gt; keySet()</code>，获取本Map集合中的所有key值，并以Set接口的结果作为返回</li>
<li><code>Collection&lt;V&gt; values()</code>，获取本Map集合中的所有value值，并以Collection接口的结果作为返回</li>
<li><code>Set&lt;Map.Entry&lt;K, V&gt;&gt; entrySet()</code>，获取本Map集合中的所有key和value值，并以<code>Set&lt;Map.Entry&lt;K, V&gt;&gt;</code>的结果作为返回</li>
<li><code>default V getOrDefault(Object key, V defaultValue)</code>，根据key获取本Map集合中的value值，如果没找到对应的值或者value值是null,则返回<code>defaultValue</code>的值</li>
<li><code>default void forEach(BiConsumer&lt;? super K, ? super V&gt; action)</code>，Java8新增的使用<code>Lambda</code>的方式遍历操作Map中的元素的默认接口方法</li>
<li><code>default void replaceAll(BiFunction&lt;? super K, ? super V, ? extends V&gt; function)</code>，Java8新增的使用<code>Lambda</code>的方式遍历替换Map中的元素的默认接口方法</li>
<li><code>default V putIfAbsent(K key, V value)</code>，Java8新增的不用写是否为null值的检测语句向Map中保存key和value的元素的默认接口方法，即如果通过key获取到的value是空的，则在调用<code>put(key, value)</code>方法并返回value值</li>
<li><code>default boolean remove(Object key, Object value)</code>，Java8新增的默认接口方法，删除给定key所对应的元素，如果value不存在、为null或者与参数中的value不等，则不能删除。即删除操作需要满足给定的值需要和map中的值相等的条件</li>
<li><code>default boolean replace(K key, V oldValue, V newValue)</code>，Java8新增的默认接口方法，替换给定key所对应的元素，如果value不存在、为null或者与参数中的oldValue不等，则不能替换。即替换操作需要满足给定的值需要和map中的值相等的条件</li>
<li><code>default V replace(K key, V value)</code>，Java8新增的默认接口方法，替换给定key所对应的元素，如果value不为null，则value值与参数中的value值做替换。</li>
<li><code>default V computeIfAbsent(K key, Function&lt;? super K, ? extends V&gt; mappingFunction)</code>，Java8新增的默认接口方法，根据key获取到的value如果不为null，则直接返回value值，否则将<code>Lambda</code>表达式中的结果值存放到Map中</li>
<li><code>default V computeIfPresent(K key, BiFunction&lt;? super K, ? super V, ? extends V&gt; remappingFunction)</code>，Java8新增的默认接口方法，根据key获取到的value和新计算的值如果不为null，则直接新计算的值，否则移除该key，且返回null</li>
<li><code>default V compute(K key, BiFunction&lt;? super K, ? super V, ? extends V&gt; remappingFunction)</code>，Java8新增的默认接口方法，将<code>Lambda</code>表达式中的结果值存放到Map中，如果计算的新值为null则返回null，且移除以前有的key和value值</li>
<li><code>default V merge(K key, V value, BiFunction&lt;? super V, ? super V, ? extends V&gt; remappingFunction)</code>，Java8新增的默认接口方法，将新计算的值覆盖Map中原key对应的value值</li>
</ul>
<h3 id="SortedSet接口中的额外抽象方法"><a href="#SortedSet接口中的额外抽象方法" class="headerlink" title="SortedSet接口中的额外抽象方法"></a>SortedSet接口中的额外抽象方法</h3><ul>
<li><code>Comparator&lt;? super E&gt; comparator()</code>，返回本SortedSet集合中的<code>Comparator</code>比较器</li>
<li><code>SortedSet&lt;E&gt; subSet(E fromElement, E toElement)</code>，获取开始元素和结束元素之间的子SortedSet集合</li>
<li><code>SortedSet&lt;E&gt; headSet(E toElement)</code>，获取开始元素和<code>toElement</code>元素之间的子SortedSet集合</li>
<li><code>SortedSet&lt;E&gt; tailSet(E fromElement)</code>，获取<code>fromElement</code>元素和结束元素之间的子SortedSet集合</li>
<li><code>E first()</code>，获取本SortedSet集合中的第一个元素</li>
<li><code>E last()</code>，获取本SortedSet集合中的最后一个元素</li>
</ul>
<h3 id="SortedMap接口中的额外抽象方法"><a href="#SortedMap接口中的额外抽象方法" class="headerlink" title="SortedMap接口中的额外抽象方法"></a>SortedMap接口中的额外抽象方法</h3><ul>
<li><code>Comparator&lt;? super K&gt; comparator()</code>，返回本SortedMap集合中的<code>Comparator</code>比较器</li>
<li><code>SortedMap&lt;K,V&gt; subMap(K fromKey, K toKey)</code>，获取开始key和结束key之间的子SortedMap集合</li>
<li><code>SortedMap&lt;K,V&gt; headMap(K toKey)</code>，获取开始key和<code>toKey</code>元素之间的子SortedMap集合</li>
<li><code>SortedMap&lt;K,V&gt; tailMap(K fromKey)</code>，获取<code>fromKey</code>元素和结束key之间的子SortedMap集合</li>
<li><code>K firstKey()</code>，获取本SortedMap集合中的第一个key</li>
<li><code>K lastKey()</code>，获取本SortedMap集合中的最后一个key</li>
<li><code>Set&lt;K&gt; keySet()</code>，获取本SortedMap集合中所有key的Set集合</li>
<li><code>Collection&lt;V&gt; values()</code>，获取本SortedMap集合中所有value的Collection集合</li>
<li><code>Set&lt;Map.Entry&lt;K, V&gt;&gt; entrySet()</code>，获取本SortedMap集合中所有key和value的Map集合</li>
</ul>

            </div>
            <hr/>

            
            <style>
    #reward {
        margin: 40px 0;
        text-align: center;
    }

    #reward .reward-link {
        font-size: 1.88rem;
    }

    #reward .btn-floating:hover {
        box-shadow: 0 6px 12px rgba(0, 0, 0, 0.2), 0 5px 15px rgba(0, 0, 0, 0.2);
    }

    #rewardModal {
        width: 320px;
        height: 350px;
    }

    #rewardModal .reward-title {
        margin: 15px auto;
        padding-bottom: 5px;
    }

    #rewardModal .modal-content {
        padding: 10px;
    }

    #rewardModal .close {
        position: absolute;
        right: 15px;
        top: 15px;
        color: rgba(0, 0, 0, 0.5);
        font-size: 1.3rem;
        line-height: 20px;
        cursor: pointer;
    }

    #rewardModal .close:hover {
        color: #ef5350;
        transform: scale(1.3);
        -moz-transform:scale(1.3);
        -webkit-transform:scale(1.3);
        -o-transform:scale(1.3);
    }

    #rewardModal .reward-tabs {
        margin: 0 auto;
        width: 210px;
    }

    .reward-tabs .tabs {
        height: 38px;
        margin: 10px auto;
        padding-left: 0;
    }

    .reward-content ul {
        padding-left: 0 !important;
    }

    .reward-tabs .tabs .tab {
        height: 38px;
        line-height: 38px;
    }

    .reward-tabs .tab a {
        color: #fff;
        background-color: #ccc;
    }

    .reward-tabs .tab a:hover {
        background-color: #ccc;
        color: #fff;
    }

    .reward-tabs .wechat-tab .active {
        color: #fff !important;
        background-color: #22AB38 !important;
    }

    .reward-tabs .alipay-tab .active {
        color: #fff !important;
        background-color: #019FE8 !important;
    }

    .reward-tabs .reward-img {
        width: 210px;
        height: 210px;
    }
</style>

<div id="reward">
    <a href="#rewardModal" class="reward-link modal-trigger btn-floating btn-large waves-effect waves-light red">赏</a>

    <!-- Modal Structure -->
    <div id="rewardModal" class="modal">
        <div class="modal-content">
            <a class="close modal-close"><i class="fa fa-close"></i></a>
            <h4 class="reward-title">你的赏识是我前进的动力</h4>
            <div class="reward-content">
                <div class="reward-tabs">
                    <ul class="tabs row">
                        <li class="tab col s6 alipay-tab waves-effect waves-light"><a href="#alipay">支付宝</a></li>
                        <li class="tab col s6 wechat-tab waves-effect waves-light"><a href="#wechat">微 信</a></li>
                    </ul>
                    <div id="alipay">
                        <img src="/medias/reward/alipay.jpg" class="reward-img" alt="支付宝打赏二维码">
                    </div>
                    <div id="wechat">
                        <img src="/medias/reward/wechat.png" class="reward-img" alt="微信打赏二维码">
                    </div>
                </div>
            </div>
        </div>
    </div>
</div>

<script>
    $(function () {
        $('.tabs').tabs();
    });
</script>
            

            <link rel="stylesheet" type="text/css" href="/libs/share/css/share.min.css">

<div id="article-share">
    
    <div class="social-share" data-disabled="qzone" data-wechat-qrcode-helper="<p>微信里点“发现”->“扫一扫”二维码便可查看分享。</p>"></div>
    
</div>

<script src="/libs/share/js/social-share.min.js"></script>

            <div class="reprint">
                <p>
                    <span class="reprint-tip">
                        <i class="fa fa-exclamation-circle"></i>&nbsp;&nbsp;转载请注明:
                    </span>
                    <a href="https://blinkfox.github.io" class="b-link-green">闪烁之狐</a>
                    <i class="fa fa-angle-right fa-lg fa-fw text-color"></i>
                    <a href="/2018/10/24/hou-duan/java/java-ji-he-kuang-jia-zhi-shi-zheng-li/" class="b-link-green">Java集合框架知识整理</a>
                </p>
            </div>
        </div>
    </div>

    
        <link rel="stylesheet" href="/libs/gitalk/gitalk.css">
<link rel="stylesheet" href="/css/my-gitalk.css">

<div class="card gitalk-card" data-aos="fade-up">
    <div id="gitalk-container" class="card-content"></div>
</div>

<script src="/libs/gitalk/gitalk.min.js"></script>
<script>
    let gitalk = new Gitalk({
        clientID: '2e56c9f3a90b6e8fb4f0',
        clientSecret: 'ba491ea79bbff85ec80b88db79e210b474a9cbc8',
        repo: 'blinkfox.github.io',
        owner: 'blinkfox',
        admin: ["blinkfox"],
        id: '2018-10-24T23-10-00',
        distractionFreeMode: false  // Facebook-like distraction free mode
    });

    gitalk.render('gitalk-container');
</script>
    

    

    

    

    

    

<article id="prenext-posts" class="prev-next articles">
    <div class="row article-row">
        
        <div class="article col s12 m6" data-aos="fade-up">
            <div class="article-badge left-badge text-color">
                <i class="fa fa-chevron-left"></i>&nbsp;上一篇</div>
            <div class="card">
                <a href="/2018/10/27/hou-duan/java/ni-xu-yao-zhi-dao-de-java-mei-ju-zhi-shi/">
                    <div class="card-image">
                        
                        <img src="http://static.blinkfox.com/20181027.jpg" class="responsive-img" alt="你需要知道的Java枚举知识">
                        
                        <span class="card-title">你需要知道的Java枚举知识</span>
                    </div>
                </a>
                <div class="card-content article-content">
                    <div class="summary">概述定义枚举（enum全称为enumeration）类型是Java 5新增的类型，存放在java.lang包中，允许用常量来表示特定的数据片断，而且全部都以类型安全的形式来表示。
定义格式 创建枚举类型要使用enum关键字，隐含了所创建的类</div>
                    <div class="publish-info">
                        <span class="publish-date">
                            <i class="fa fa-clock-o fa-fw icon-date"></i>2018-10-27
                        </span>
                        <span class="publish-author">
                            
                            <i class="fa fa-bookmark fa-fw icon-category"></i>
                            
                            <a href="/categories/后端/" class="post-category" target="_blank">
                                    后端
                                </a>
                            
                            
                        </span>
                    </div>
                </div>
                
                <div class="card-action article-tags">
                    
                    <a href="/tags/Java/" target="_blank">
                        <span class="chip bg-color">Java</span>
                    </a>
                    
                </div>
                
            </div>
        </div>
        
        
        <div class="article col s12 m6" data-aos="fade-up">
            <div class="article-badge right-badge text-color">
                下一篇&nbsp;<i class="fa fa-chevron-right"></i>
            </div>
            <div class="card">
                <a href="/2018/10/22/ruan-jian-she-ji/uml-ge-lei-guan-xi-jie-shao/">
                    <div class="card-image">
                        
                        <img src="http://static.blinkfox.com/20181022-organ.jpg" class="responsive-img" alt="UML各类关系介绍">
                        
                        <span class="card-title">UML各类关系介绍</span>
                    </div>
                </a>
                <div class="card-content article-content">
                    <div class="summary">继承关系（generalization）继承关系用一条带空心箭头的直线表示。如下图所示（A继承自B）：

继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力。继承关系为is-a的关</div>
                    <div class="publish-info">
                            <span class="publish-date">
                                <i class="fa fa-clock-o fa-fw icon-date"></i>2018-10-22
                            </span>
                        <span class="publish-author">
                            
                            <i class="fa fa-bookmark fa-fw icon-category"></i>
                            
                            <a href="/categories/软件设计/" class="post-category" target="_blank">
                                    软件设计
                                </a>
                            
                            
                        </span>
                    </div>
                </div>
                
                <div class="card-action article-tags">
                    
                    <a href="/tags/Java/" target="_blank">
                        <span class="chip bg-color">Java</span>
                    </a>
                    
                    <a href="/tags/面向对象编程/" target="_blank">
                        <span class="chip bg-color">面向对象编程</span>
                    </a>
                    
                    <a href="/tags/UML/" target="_blank">
                        <span class="chip bg-color">UML</span>
                    </a>
                    
                </div>
                
            </div>
        </div>
        
    </div>
</article>
</div>


    </div>
    <div class="col l3 hide-on-med-and-down">
        <div class="toc-widget">
            <div class="toc-title"><i class="fa fa-list-alt"></i>&nbsp;&nbsp;目录</div>
            <div id="toc-content"></div>
        </div>
    </div>
</div>

<script src="/libs/tocbot/tocbot.min.js"></script>
<script>
    $(function () {
        tocbot.init({
            tocSelector: '#toc-content',
            contentSelector: '#articleContent',
            headingsOffset: -($(window).height() * 0.4 - 45),
            // headingsOffset: -205,
            headingSelector: 'h2, h3, h4'
        });

        // modify the toc link href to support Chinese.
        let i = 0;
        let tocHeading = 'toc-heading-';
        $('#toc-content a').each(function () {
            $(this).attr('href', '#' + tocHeading + (++i));
        });

        // modify the heading title id to support Chinese.
        i = 0;
        $('#articleContent').children('h2, h3, h4').each(function () {
            $(this).attr('id', tocHeading + (++i));
        });

        // Set scroll toc fixed.
        let tocHeight = parseInt($(window).height() * 0.4 - 64);
        let $tocWidget = $('.toc-widget');
        $(window).scroll(function () {
            let scroll = $(window).scrollTop();
            /* add post toc fixed. */
            if (scroll > tocHeight) {
                $tocWidget.addClass('toc-fixed');
            } else {
                $tocWidget.removeClass('toc-fixed');
            }
        });
    });
</script>
    

</main>


<footer class="page-footer bg-color">
    <div class="container row center-align">
        <div class="col s12 m8 l8 copy-right">
            本站由&copy;<a href="https://blinkfox.github.io/" target="_blank">Blinkfox</a>基于
            <a href="https://hexo.io/" target="_blank">Hexo</a> 的
            <a href="https://github.com/blinkfox/hexo-theme-matery" target="_blank">hexo-theme-matery</a>主题搭建.

            
                &nbsp;<i class="fa fa-area-chart"></i>&nbsp;站点总字数:&nbsp;
                <span class="white-color">194.7k</span>
            

            
			
                <br>
                
                <span id="busuanzi_container_site_pv">
                    <i class="fa fa-heart-o"></i>
                    本站总访问量 <span id="busuanzi_value_site_pv" class="white-color"></span>
                </span>
                
                
                <span id="busuanzi_container_site_uv">
                    <i class="fa fa-users"></i>
                    次,&nbsp;访客数 <span id="busuanzi_value_site_uv" class="white-color"></span> 人.
                </span>
                
            
        </div>
        <div class="col s12 m4 l4 social-link social-statis">
    <a href="https://github.com/blinkfox/" class="tooltipped" target="_blank" data-tooltip="访问我的GitHub" data-position="top" data-delay="50">
        <i class="fa fa-github"></i>
    </a>



    <a href="mailto:chenjiayin1990@163.com" class="tooltipped" target="_blank" data-tooltip="邮件联系我" data-position="top" data-delay="50">
        <i class="fa fa-envelope-open"></i>
    </a>



    <a href="tencent://AddContact/?fromId=50&fromSubId=1&subcmd=all&uin=1181062873" class="tooltipped" data-tooltip="QQ联系我: 1181062873" data-position="top" data-delay="50">
        <i class="fa fa-qq"></i>
    </a>



    <a href="/atom.xml" class="tooltipped" target="_blank" data-tooltip="RSS 订阅" data-position="top" data-delay="50">
        <i class="fa fa-rss"></i>
    </a>
</div>
    </div>
</footer>

<div class="progress-bar"></div>


<!-- 搜索遮罩框 -->
<div id="searchModal" class="modal">
    <div class="modal-content">
        <div class="search-header">
            <span class="title"><i class="fa fa-search"></i>&nbsp;&nbsp;搜索</span>
            <input type="search" id="searchInput" name="s" placeholder="请输入搜索的关键字"
                   class="search-input">
        </div>
        <div id="searchResult"></div>
    </div>
</div>

<script src="/js/search.js"></script>
<script type="text/javascript">
$(function () {
    searchFunc("/" + "search.xml", 'searchInput', 'searchResult');
});
</script>
<!-- 回到顶部按钮 -->
<div id="backTop" class="top-scroll">
    <a class="btn-floating btn-large waves-effect waves-light" href="#!">
        <i class="fa fa-angle-up"></i>
    </a>
</div>


<script src="/libs/materialize/materialize.min.js"></script>
<script src="/libs/masonry/masonry.pkgd.min.js"></script>
<script src="/libs/aos/aos.js"></script>
<script src="/libs/scrollprogress/scrollProgress.min.js"></script>
<script src="/libs/lightGallery/js/lightgallery-all.min.js"></script>
<script src="/js/matery.js"></script>

<!-- Global site tag (gtag.js) - Google Analytics -->



    <script src="/libs/others/clicklove.js"></script>


    <script async src="/libs/others/busuanzi.pure.mini.js"></script>


</body>
</html>